home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK2.toast / Development Kits (Disc 2) / OpenDoc Development Framework / Tools & Goodies / IntlTest / Sources / Commands.cpp < prev    next >
Encoding:
Text File  |  1996-09-12  |  18.7 KB  |  601 lines  |  [TEXT/MPS ]
  1. //========================================================================================
  2. //
  3. //    File:                Commands.cpp
  4. //    Release Version:    $ ODF 2 $
  5. //
  6. //    Copyright:            (c) 1993 - 1996 by Apple Computer, Inc., all rights reserved.
  7. //
  8. //========================================================================================
  9.  
  10. #include "IntlTest.hpp"
  11.  
  12. #ifndef COMMANDS_H
  13. #include "Commands.h"
  14. #endif
  15.  
  16. #ifndef PART_H
  17. #include "Part.h"
  18. #endif
  19.  
  20. #ifndef FRAME_H
  21. #include "Frame.h"
  22. #endif
  23.  
  24. #ifndef CONTENT_H
  25. #include "Content.h"
  26. #endif
  27.  
  28. #ifndef EDITVIEWS_H
  29. #include "EditViews.h"
  30. #endif
  31.  
  32. #ifndef SELECT_H
  33. #include "Select.h"
  34. #endif
  35.  
  36. // ----- Framework Includes -----
  37.  
  38. #ifndef FWPRESEN_H
  39. #include "FWPresen.h"
  40. #endif
  41.  
  42. // ----- OpenDoc Includes -----
  43.  
  44. #ifndef SOM_Module_OpenDoc_Commands_defined
  45. #include <CmdDefs.xh>
  46. #endif
  47.  
  48. //========================================================================================
  49. // RunTime Info
  50. //========================================================================================
  51.  
  52. #ifdef FW_BUILD_MAC
  53. #pragma segment odfIntlTest
  54. #endif
  55.  
  56. //========================================================================================
  57. // CIntlTestDropCommand
  58. //========================================================================================
  59.  
  60. FW_DEFINE_AUTO(CIntlTestDropCommand)
  61.  
  62. //----------------------------------------------------------------------------------------
  63. //    CIntlTestDropCommand constructor
  64. //----------------------------------------------------------------------------------------
  65.  
  66. CIntlTestDropCommand::CIntlTestDropCommand(Environment* ev,
  67.                                     FW_CFrame* frame,
  68.                                     FW_CEditView* dropView,
  69.                                     CIntlTestSelection* selection,
  70.                                     ODDragItemIterator* dropInfo, 
  71.                                     ODFacet* odFacet,
  72.                                     const FW_CPoint& dropPoint) : 
  73.     FW_CDropCommand(ev, frame, dropInfo, odFacet, dropPoint, FW_kCanUndo),
  74.     fDropEditView(dropView),
  75.     fTextSelection(selection),
  76.     fSavedOffset(0)
  77. {
  78.     // Ensure that dropped text is Internalized into the drop view
  79.     selection->SetContentEditView(dropView);
  80.  
  81.     SetMenuStringsFromResource(ev, kIntlTestUndoStrings, kUndoDropTextMsg, kRedoDropTextMsg);
  82.     FW_END_CONSTRUCTOR
  83. }
  84.  
  85. //----------------------------------------------------------------------------------------
  86. //    CIntlTestDropCommand destructor
  87. //----------------------------------------------------------------------------------------
  88.  
  89. CIntlTestDropCommand::~CIntlTestDropCommand()
  90. {
  91.     FW_START_DESTRUCTOR
  92. }
  93.  
  94. //----------------------------------------------------------------------------------------
  95. //    CIntlTestDropCommand::SaveUndoState
  96. //----------------------------------------------------------------------------------------
  97.  
  98. void CIntlTestDropCommand::SaveUndoState(Environment* ev)
  99. {
  100.     short endOffset;
  101.     fSavedText = fDropEditView->GetSelectedText(ev);
  102.     fDropEditView->GetSelectionRange(ev, fSavedOffset, endOffset);
  103. }
  104.  
  105. //----------------------------------------------------------------------------------------
  106. //    CIntlTestDropCommand::SaveRedoState
  107. //----------------------------------------------------------------------------------------
  108. void CIntlTestDropCommand::SaveRedoState(Environment*)
  109. {
  110.     fDroppedText = fTextSelection->GetSelectedTestContent()->GetInternalizedText();
  111. }
  112.  
  113. //----------------------------------------------------------------------------------------
  114. //    CIntlTestDropCommand::UndoIt
  115. //----------------------------------------------------------------------------------------
  116.  
  117. void CIntlTestDropCommand::UndoIt(Environment* ev)
  118. {
  119.     this->SwapText(ev, fDroppedText.GetByteLength(), fSavedText);
  120. }
  121.  
  122. //----------------------------------------------------------------------------------------
  123. //    CIntlTestDropCommand::RedoIt
  124. //----------------------------------------------------------------------------------------
  125.  
  126. void CIntlTestDropCommand::RedoIt(Environment* ev)
  127. {
  128.     this->SwapText(ev, fSavedText.GetByteLength(), fDroppedText);
  129. }
  130.  
  131. //----------------------------------------------------------------------------------------
  132. //    CIntlTestDropCommand::SwapText
  133. //----------------------------------------------------------------------------------------
  134.  
  135. void CIntlTestDropCommand::SwapText(Environment* ev, FW_ByteCount bytesToRemove,
  136.                                     const FW_CString& textToRestore)
  137. {
  138.     // Remove designated text
  139.     fDropEditView->SelectText(ev, fSavedOffset, fSavedOffset+(short)bytesToRemove);
  140.     fDropEditView->DoTECommand(ev, kODCommandClear, true);
  141.  
  142.     // Restore the text
  143.     fDropEditView->InsertText(ev, textToRestore, fSavedOffset);
  144. }
  145.  
  146. //========================================================================================
  147. //    class CIntlTestEditCommand
  148. //========================================================================================
  149.  
  150. FW_DEFINE_AUTO(CIntlTestEditCommand)
  151.  
  152. //----------------------------------------------------------------------------------------
  153. //    CIntlTestEditCommand constructor
  154. //----------------------------------------------------------------------------------------
  155. CIntlTestEditCommand::CIntlTestEditCommand(Environment* ev, 
  156.                             ODCommandID commandID,
  157.                             FW_CFrame* frame,
  158.                             CIntlTestSelection* selection,
  159.                             FW_CEditView* editView,
  160.                             FW_Boolean canUndo)
  161. :    FW_CClipboardCommand(ev, commandID, frame, canUndo),
  162.     fTextSelection(selection),
  163.     fEditView(editView),
  164.     fStartOffset(0),
  165.     fEndOffset(0)
  166. {
  167.     if (editView)
  168.         fTextSelection->SetContentEditView(editView);
  169.     FW_END_CONSTRUCTOR
  170. }
  171.  
  172. //----------------------------------------------------------------------------------------
  173. //    CIntlTestEditCommand destructor
  174. //----------------------------------------------------------------------------------------
  175. CIntlTestEditCommand::~CIntlTestEditCommand()
  176. {
  177.     FW_START_DESTRUCTOR
  178. }
  179.  
  180. //----------------------------------------------------------------------------------------
  181. //    CIntlTestEditCommand::PreCommand
  182. //----------------------------------------------------------------------------------------
  183. void CIntlTestEditCommand::PreCommand(Environment* ev)
  184. {
  185.     ODCommandID id = GetCommandID(ev);
  186.     if ((id == kODCommandCopy) || (id == kODCommandCut))
  187.         fEditView->DoTECommand(ev, kODCommandCopy, true);    // Tell TE to copy the text
  188. }
  189.  
  190. //----------------------------------------------------------------------------------------
  191. //    CIntlTestEditCommand::SaveUndoState
  192. //----------------------------------------------------------------------------------------
  193. void CIntlTestEditCommand::SaveUndoState(Environment* ev)
  194. {
  195.     switch (GetCommandID(ev))
  196.     {
  197.         case kODCommandCut:
  198.         case kODCommandClear:
  199.             fPastedText = fEditView->GetSelectedText(ev);
  200.             fEditView->GetSelectionRange(ev, fStartOffset, fEndOffset);
  201.             break;
  202.  
  203.         case kODCommandPaste:
  204.             fSavedText = fEditView->GetSelectedText(ev);
  205.             fEditView->GetSelectionRange(ev, fStartOffset, fEndOffset);
  206.             break;
  207.     }
  208. }
  209.  
  210. //----------------------------------------------------------------------------------------
  211. //    CIntlTestEditCommand::SaveRedoState
  212. //----------------------------------------------------------------------------------------
  213. void CIntlTestEditCommand::SaveRedoState(Environment* ev)
  214. {
  215.     if (GetCommandID(ev) == kODCommandPaste)
  216.     {
  217.         fPastedText = fTextSelection->GetSelectedTestContent()->GetInternalizedText();
  218.     }
  219. }
  220.  
  221. //----------------------------------------------------------------------------------------
  222. //    CIntlTestEditCommand::UndoIt
  223. //----------------------------------------------------------------------------------------
  224. void CIntlTestEditCommand::UndoIt(Environment* ev)
  225. {
  226.     FW_CClipboardCommand::UndoIt(ev);    // call inherited
  227.  
  228.     switch (GetCommandID(ev))
  229.     {
  230.         case kODCommandCut:
  231.         case kODCommandClear:
  232.             this->RestoreText(ev);
  233.             break;
  234.  
  235.         case kODCommandPaste:
  236.             this->RemoveAndRestoreText(ev, fPastedText.GetByteLength(), fSavedText);
  237.             break;
  238.     }    
  239. }
  240.  
  241. //----------------------------------------------------------------------------------------
  242. //    CIntlTestEditCommand::RedoIt
  243. //----------------------------------------------------------------------------------------
  244. void CIntlTestEditCommand::RedoIt(Environment* ev)
  245. {
  246.     FW_CClipboardCommand::RedoIt(ev);    // call inherited
  247.  
  248.     switch (GetCommandID(ev))
  249.     {
  250.         case kODCommandCut:
  251.         case kODCommandClear:
  252.             this->RemoveText(ev);
  253.             break;
  254.  
  255.         case kODCommandPaste:
  256.             this->RemoveAndRestoreText(ev, fSavedText.GetByteLength(), fPastedText);
  257.             break;
  258.     }    
  259. }
  260.  
  261. //----------------------------------------------------------------------------------------
  262. //    CIntlTestEditCommand::RemoveText
  263. //----------------------------------------------------------------------------------------
  264. void CIntlTestEditCommand::RemoveText(Environment* ev)
  265. {
  266.     fEditView->SelectText(ev, fStartOffset, fEndOffset);
  267.     fEditView->DoTECommand(ev, kODCommandClear, true);
  268. }
  269.  
  270. //----------------------------------------------------------------------------------------
  271. //    CIntlTestEditCommand::RestoreText
  272. //----------------------------------------------------------------------------------------
  273. void CIntlTestEditCommand::RestoreText(Environment* ev)
  274. {
  275.     // Insert the saved text back into the EditView
  276.     fEditView->InsertText(ev, fPastedText, fStartOffset);
  277. }
  278.  
  279. //----------------------------------------------------------------------------------------
  280. //    CIntlTestEditCommand::RemoveAndRestoreText
  281. //----------------------------------------------------------------------------------------
  282. void CIntlTestEditCommand::RemoveAndRestoreText(Environment* ev, FW_ByteCount bytesToRemove,
  283.                                                 const FW_CString& textToRestore)
  284. {
  285.     // Remove designated text
  286.     fEditView->SelectText(ev, fStartOffset, fStartOffset+(short)bytesToRemove);
  287.     fEditView->DoTECommand(ev, kODCommandClear, true);
  288.  
  289.     // Restore the text
  290.     fEditView->InsertText(ev, textToRestore, fStartOffset);
  291. }
  292.  
  293. //========================================================================================
  294. // CTypingCommand
  295. //========================================================================================
  296.  
  297. FW_DEFINE_AUTO(CTypingCommand)
  298.  
  299. //-----------------------------------------------------------------------------------------
  300. CTypingCommand::CTypingCommand(Environment* ev, 
  301.                                ODCommandID commandID,
  302.                                FW_CFrame* frame, 
  303.                                FW_CEditView* editView,
  304.                                FW_Boolean canUndo,
  305.                                char firstChar)
  306. :    FW_CCommand(ev, commandID, frame, canUndo),
  307.     fEditView(editView),
  308.     fCompleted(false),
  309.     fFirstChar(firstChar),
  310.     fTypedText(""),
  311.     fSavedText(""),
  312.     fStartOffset(0),
  313.     fEndOffset(0)
  314. {
  315.     SetMenuStrings(ev, "Undo Typing", "Redo Typing");
  316.     FW_END_CONSTRUCTOR
  317. }
  318.  
  319. //-----------------------------------------------------------------------------------------
  320. CTypingCommand::~CTypingCommand()
  321. {
  322.     FW_START_DESTRUCTOR
  323.  
  324.     // notify edit view that we're going away
  325.     ((CMyEditView*)fEditView)->TypingCommandAboutToBeDestroyed(this);
  326. }
  327.  
  328. //-----------------------------------------------------------------------------------------
  329. void CTypingCommand::AddCharacter(Environment* ev, char ch)
  330. {
  331.     if (ch == chBackspace)
  332.         Backspace(ev, ch);
  333.     else
  334.         fTypedText.Append(ch);
  335. }
  336.  
  337. //-----------------------------------------------------------------------------------------
  338. void CTypingCommand::Backspace(Environment* ev, char /*bsChar*/)
  339. {
  340.     short startOffset, endOffset;
  341.     fEditView->GetSelectionRange(ev, startOffset, endOffset);
  342.  
  343.     if ((startOffset == 0) && (endOffset == 0)) return;    // nothing to backspace over
  344.  
  345.     //--- Are we deleting a selection?
  346.     if (endOffset != startOffset)            // some text is selected
  347.     {
  348.         fTypedText = "";                    // replace selection w/empty string
  349.     }
  350.     else if (startOffset <= fStartOffset)    // Backspacing past the start of typing
  351.     {
  352.         // save the character we're about to backspace over
  353.         FW_PlatformHandle teh = fEditView->GetPlatformEditHandle(ev);
  354.         TERec* tep = (TERec*) *teh;
  355.         char* p = (char*) (*(tep->hText)) + startOffset - 1;
  356.         fSavedText.Insert(p, 1, 0);
  357.         fStartOffset--;
  358.     }
  359.     else                                    // backspace over typed text
  360.     {
  361.         FW_ByteCount count = fTypedText.GetByteLength();
  362.         fTypedText.Truncate(count-1);        // cut off the last character of the saved text
  363.     }
  364. }
  365.  
  366. //-----------------------------------------------------------------------------------------
  367. void CTypingCommand::CompleteTyping(Environment* ev)
  368. {
  369.     if (fCompleted) return;
  370.  
  371.     if (!fTypedText.IsEmpty())
  372.     {
  373.         if (GetCanUndo(ev))
  374.             this->SaveRedoState(ev);        // save new state, for later Redo
  375.     
  376.         fCompleted = true;
  377.     }
  378. }
  379.  
  380. //-----------------------------------------------------------------------------------------
  381. void CTypingCommand::DoIt(Environment* ev)
  382. {
  383.     if (GetCanUndo(ev))
  384.         this->SaveUndoState(ev);        // save current state, for later Undo
  385.  
  386.     AddCharacter(ev, fFirstChar);
  387. }
  388.  
  389. //-----------------------------------------------------------------------------------------
  390. void CTypingCommand::SaveUndoState(Environment* ev)
  391. {
  392.     // Get current selection info, for Undo
  393.     fSavedText = fEditView->GetSelectedText(ev);
  394.     fEditView->GetSelectionRange(ev, fStartOffset, fEndOffset);
  395. }
  396.  
  397. //-----------------------------------------------------------------------------------------
  398. void CTypingCommand::SaveRedoState(Environment*)
  399. {
  400.     // fTypedText contains the new text - what else do we need?
  401. }
  402.  
  403. //-----------------------------------------------------------------------------------------
  404. void CTypingCommand::UndoIt(Environment* ev)
  405. {
  406.     this->CompleteTyping(ev);
  407.  
  408.     fEditView->SelectText(ev, fStartOffset, fStartOffset+fTypedText.GetByteLength());
  409.     fEditView->SetSelectedText(ev, fSavedText);
  410. }
  411.  
  412. //-----------------------------------------------------------------------------------------
  413. void CTypingCommand::RedoIt(Environment* ev)
  414. {
  415.     fEditView->SelectText(ev, fStartOffset, fStartOffset+fSavedText.GetByteLength());
  416.     fEditView->SetSelectedText(ev, fTypedText);
  417. }
  418.  
  419. //========================================================================================
  420. //    class CTSMTypingCommand
  421. //========================================================================================
  422.  
  423. FW_DEFINE_AUTO(CTSMTypingCommand)
  424.  
  425. //-----------------------------------------------------------------------------------------
  426. CTSMTypingCommand::CTSMTypingCommand(Environment* ev, 
  427.                                      ODCommandID commandID,
  428.                                      FW_CFrame* frame, 
  429.                                      FW_CEditView* editView,
  430.                                      CTSMInput* firstInput)
  431. :    CTypingCommand(ev, commandID, frame, editView, FW_kCanUndo, 0),
  432.     fFirstInput(firstInput)
  433. {
  434.     FW_END_CONSTRUCTOR
  435. }
  436.  
  437. //-----------------------------------------------------------------------------------------
  438. CTSMTypingCommand::~CTSMTypingCommand()
  439. {
  440.     FW_START_DESTRUCTOR
  441. }
  442.  
  443. //-----------------------------------------------------------------------------------------
  444. void CTSMTypingCommand::AddInput(Environment* ev, CTSMInput* input)
  445. {
  446.     if (input->IsMultiByte())
  447.         fTypedText.Append(input->fChars, input->fByteCount);
  448.     else if (input->fByte == chBackspace)
  449.         Backspace(ev);
  450.     else
  451.         fTypedText.Append(input->fByte);
  452. }
  453.  
  454. //-----------------------------------------------------------------------------------------
  455. void CTSMTypingCommand::Backspace(Environment* ev)
  456. {
  457.     short bytesPerChar = 2;
  458.     short startOffset, endOffset;
  459.     fEditView->GetSelectionRange(ev, startOffset, endOffset);
  460.  
  461.     if ((startOffset == 0) && (endOffset == 0)) return;    // nothing to backspace over
  462.  
  463.     //--- Are we deleting a selection?
  464.     if (endOffset != startOffset)            // some text is selected
  465.     {
  466.         fTypedText = "";                    // replace selection w/empty string
  467.     }
  468.     else if (startOffset <= fStartOffset)    // Backspacing past the start of typing
  469.     {
  470.         // save the character we're about to backspace over
  471.         FW_PlatformHandle teh = fEditView->GetPlatformEditHandle(ev);
  472.         TERec* tep = (TERec*) *teh;
  473.         char* p = (char*) (*(tep->hText)) + startOffset;
  474.         // Check if the previous character is a single-byte CR
  475.         --p;
  476.         if (*p == chReturn)
  477.             bytesPerChar = 1;
  478.         else
  479.             --p;
  480.         fSavedText.Insert(p, bytesPerChar, 0);
  481.         fStartOffset -= bytesPerChar;
  482.     }
  483.     else                                    // backspace over typed text
  484.     {
  485.         FW_ByteCount count = fTypedText.GetByteLength();
  486.         FW_ASSERT(count > 0);
  487.         // Check if the last typed character is a single-byte CR
  488.         if (fTypedText[count-1] == chReturn)        // FW_CString oper[] is 0-based
  489.             bytesPerChar = 1;
  490.         else if (count == 1)                        // kludge
  491.             bytesPerChar = 1;
  492.         fTypedText.Truncate(count-bytesPerChar);    // cut off the last character of the saved text
  493.     }
  494. }
  495.  
  496. //-----------------------------------------------------------------------------------------
  497. void CTSMTypingCommand::DoIt(Environment* ev)
  498. {
  499.     if (GetCanUndo(ev))
  500.         this->SaveUndoState(ev);            // save current state, for later Undo
  501.  
  502.     if (fFirstInput)
  503.     {
  504.         AddInput(ev, fFirstInput);
  505.         fFirstInput = NULL;                    // only valid for this one time
  506.     }
  507. }
  508.  
  509.  
  510. //========================================================================================
  511. // CFontCommand
  512. //========================================================================================
  513.  
  514. FW_DEFINE_AUTO(CFontCommand)
  515.  
  516. //----------------------------------------------------------------------------------------
  517. CFontCommand::CFontCommand(Environment* ev, 
  518.                            ODCommandID id,
  519.                            FW_CFrame* frame, 
  520.                            CMyEditView* editView)
  521. :    FW_CCommand(ev, id, frame, FW_kCanUndo),
  522.     fEditView(editView)
  523. {
  524.     fNameChange = (cFirstFontCommand <= id && id < cFirstFontCommand+gFontCount);
  525.     if (fNameChange)
  526.         SetMenuStringsFromResource(ev, kIntlTestUndoStrings, kUndoFontChangeMsg, kRedoFontChangeMsg);
  527.     else    // size change
  528.         SetMenuStringsFromResource(ev, kIntlTestUndoStrings, kUndoFontSizeMsg, kRedoFontSizeMsg);
  529.     FW_END_CONSTRUCTOR
  530. }
  531.  
  532. //----------------------------------------------------------------------------------------
  533. CFontCommand::~CFontCommand()
  534. {
  535.     FW_START_DESTRUCTOR
  536. }
  537.  
  538. //----------------------------------------------------------------------------------------
  539. void CFontCommand::DoIt(Environment* ev)
  540. {
  541.     // Save Undo state (current font)
  542.     fOldFont = fEditView->GetCurrentFont();
  543.     fOldFontCommand = fEditView->GetCurrentFontCmd(ev);
  544.  
  545.     // Change font
  546.     ODCommandID id = GetCommandID(ev);
  547.     if (fNameChange)
  548.     {
  549.         FW_CString fontName;
  550.         fEditView->CommandToString(ev, id, fontName);
  551.         fEditView->DoSetFont(ev, id, fontName);
  552.     }
  553.     else    // size change
  554.     {
  555.         FW_CString sizeString;
  556.         fEditView->CommandToString(ev, id, sizeString);
  557.         int fontSize = sizeString.ParseAsUnsignedInteger();
  558.         fEditView->DoSetFontSize(ev, fontSize);
  559.     }
  560.  
  561.     // Save Redo state (new font)
  562.     fNewFont = fEditView->GetCurrentFont();
  563. }
  564.  
  565. //----------------------------------------------------------------------------------------
  566. void CFontCommand::UndoIt(Environment* ev)
  567. {
  568.     // Set editView's font to the old one
  569.     ODCommandID id = GetCommandID(ev);
  570.     if (fNameChange)
  571.     {
  572.         FW_CString fontName;
  573.         fOldFont.GetFontName(fontName);
  574.         fEditView->DoSetFont(ev, fOldFontCommand, fontName);
  575.     }
  576.     else    // size change
  577.     {
  578.         int fontSize = FW_FixedToInt(fOldFont.GetFontSize());
  579.         fEditView->DoSetFontSize(ev, fontSize);
  580.     }
  581. }
  582.  
  583. //----------------------------------------------------------------------------------------
  584. void CFontCommand::RedoIt(Environment* ev)
  585. {
  586.     ODCommandID id = GetCommandID(ev);
  587.     if (fNameChange)
  588.     {
  589.         FW_CString fontName;
  590.         fNewFont.GetFontName(fontName);
  591.         fEditView->DoSetFont(ev, id, fontName);
  592.     }
  593.     else    // size change
  594.     {
  595.         int fontSize = FW_FixedToInt(fNewFont.GetFontSize());
  596.         fEditView->DoSetFontSize(ev, fontSize);
  597.     }
  598. }
  599.  
  600.  
  601.